package com.zhj.bz.algorithm.sort.swap;

import com.zhj.tool.CallBack;
import com.zhj.tool.TimeTools;

import java.util.Arrays;

/**
 * 快速排序，在冒泡的基础上应用了分治的思想
 * 简单而又快速，缺点就是不稳定，排序后无法保证相同数字的先后次序
 * 步骤：
 *      1. 首先从数列中找一个基准点
 *      2. 重新排序数列，所有比基准小的放前边，比基准大的放后边，相同的可以放任意一边
 *      3. 递归，把小于基准值的子数列和大于基准值的子数列排序
 *
 *      eg:
 *      第一次 8, 9, 1, 7, 2, 4, 6, 0, 3
 *      第二次 3, 1, 7, 2, 4, 6, 0, 8, 9
 *      分治： 选取比基准大的放右边，最后将基准点与最后一个符合条件的交换位置，分治的中间节点为基准点最后放置位置的前一个位置
 *      left: 0, 1, 2, 3, 4, 6, 7
 *      right: 8, 9
 */
public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 4, 6, 0, 3};
        quickSort(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(arr));
        int[] bigArr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            bigArr[i] = (int) (Math.random() * 80000);
        }
        System.out.println("快速排序：");
        TimeTools.useTime(new CallBack(){
            //定义execute方法
            public void execute(){
                quickSort(bigArr, 0, bigArr.length-1);
            }
        });
    }

    public static void sort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int pivot = arr[(left + right) / 2];
        int temp;
        while (l < r) {
            while (arr[l] < pivot) {
                l++;
            }
            while (arr[r] > pivot) {
                r--;
            }
            if (l >= r) {
                break;
            }
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            if (arr[l] == pivot) {
                r--;
            }
            if (arr[r] == pivot) {
                l++;
            }
        }
        if ( l == r) {
            l++;
            r--;
        }
        if (left < r) {
            sort(arr, left , r);
        }
        if (right > l) {
            sort(arr, l , right);
        }
    }

    public static int[] quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
        return arr;
    }

    /**
     * 分区
     * @param arr
     * @param left
     * @param right
     * @return
     */
    private static int partition(int[] arr, int left, int right) {
        // 基准点
        int pivot = left;
        // 游标
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            // 排序，将基准点之后的与基准点比较
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        // 将基准点与游标交换位置
        swap(arr, pivot, index - 1);
        return index - 1;
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
